package com.zretc.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.zretc.dao.*;
import com.zretc.entity.*;
import com.zretc.service.FilmService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class FilmServiceImpl implements FilmService {

    private static final Logger logger = LoggerFactory.getLogger(FilmServiceImpl.class);

    @Autowired
    private FilmMapper filmMapper;

    @Autowired
    private FilmActorMapper filmActorMapper;

    @Autowired
    private ActorMapper actorMapper;

    @Autowired
    private FilmTypeRelationMapper filmTypeRelationMapper;

    @Autowired
    private FilmRankMapper filmRankMapper;

    @Autowired
    private FilmTypeMapper filmTypeMapper;

    @Override
    @Transactional
    public boolean insertFilm(Film film) {

        FilmTypeRelation filmTypeRelation = null;
        FilmRank filmRank = null;
        FilmActor filmActor= null;
        FilmType filmType = null;
        Actor actor = null;

        // 获取影片演员关系表数据
        List<Actor> actorList = film.getActorList();
        // 获取影片分类详情表数据
        List<FilmType> filmTypeList = film.getFilmTypeList();

        // 对影片表插入数据
        int i = filmMapper.insertFilm(film);

        // 获取影片编号
        Integer filmId = film.getFilmId();
        logger.info("========================" + filmId);

        // 对影片分类详情表插入数据
        for (FilmType filmTypelist:filmTypeList) {
            filmTypeRelation = new FilmTypeRelation();

            // 对影片分类详情表的影片编号插入数据
            film = new Film();
            film.setFilmId(filmId);
            filmTypeRelation.setFilm(film);

            // 通过类型名称查询到该类型的编号
            String filmTypeName = filmTypelist.getFilmTypeName();

            FilmType filmTypeByFilmTypeName = filmTypeMapper.findFilmTypeByFilmTypeName(filmTypeName);

            Integer filmTypeId = filmTypeByFilmTypeName.getFilmTypeId();
            // 对影片分类详情表的类型编号插入数据
            filmType = new FilmType();
            filmType.setFilmTypeId(filmTypeId);
            filmTypeRelation.setFilmType(filmType);

            int lei = filmTypeRelationMapper.insertFilmTypeRelation(filmTypeRelation);
            if (lei > 0) {
                logger.info("=================================影片分类详情表插入成功==========================");
            } else {
                logger.info("======================================影片分类详情表插入失败==========================");
            }
        }
        // 对影片演员关系表插入数据
        for (Actor actorlist:actorList) {
            // 通过演员名称查询数据库表有没有该演员
            String actorName = actorlist.getActorName();
            Actor actorByActorName1 = actorMapper.findActorByActorName(actorName);
            logger.info("=================================actorByActorName1:" + actorByActorName1);

            if (actorByActorName1 == null) {
                // 如果演员表没有此演员，则对其插入新的演员数据
                actor = new Actor();
                actor.setActorName(actorName);
                int xyy = actorMapper.insertActor(actor);
                if (xyy > 0) {
                    logger.info("=================================新演员插入成功==========================");
                } else {
                    logger.info("======================================新演员插入失败==========================");
                }
                Integer actorId1 = actor.getActorId();
                logger.info("================================================================新的演员编号" + actorId1 );
                // 对影片演员关系表插入数据
                filmActor = new FilmActor();
                // 对影片演员关系表的影片编号插入数据
                film = new Film();
                film.setFilmId(filmId);
                filmActor.setFilm(film);
                // 对影片演员关系表的演员编号插入数据
                actor = new Actor();
                actor.setActorId(actorId1);
                filmActor.setActor(actor);

                int yy = filmActorMapper.insertFilmActor(filmActor);
                if (yy > 0) {
                    logger.info("====================================用新的演员编号对影片演员关系表插入成功" );
                } else {
                    logger.info("========================用新的演员编号对影片演员关系表插入失败===========================================" );
                }
            } else {
                // 如果演员表有此演员，则对其影片演员关系表插入数据
                filmActor = new FilmActor();
                // 对影片演员详情表的影片编号插入数据
                film = new Film();
                film.setFilmId(filmId);
                filmActor.setFilm(film);
                // 通过类型名称查询到该类型的编号
                Actor actorByActorName2 = actorMapper.findActorByActorName(actorName);
                Integer actorId2 = actorByActorName2.getActorId();
                // 对影片演员关系表的演员编号插入数据
                actor = new Actor();
                actor.setActorId(actorId2);
                filmActor.setActor(actor);
                int n2 = filmActorMapper.insertFilmActor(filmActor);
                if (n2 > 0) {
                    logger.info("====================================影片演员关系表插入成功" );
                } else {
                    logger.info("========================影片演员关系表插入失败===========================================" );
                }
            }
        }

        // 获取排行榜列表的最后一个排名
        FilmRank filmRankLast = filmRankMapper.findFilmRankLast();
        Integer number = 0;
        if (filmRankLast == null) {
            number = 1;
            // 对影片排行榜表插入数据
            filmRank = new FilmRank();
            film = new Film();
            film.setFilmId(filmId);
            filmRank.setFilm(film);
            logger.info("====================================新的排名：" + number );
            filmRank.setRankNumber(number);

            int i1 = filmRankMapper.insertFilmRank(filmRank);
            if (i1 > 0) {
                logger.info("====================================影片排行榜数据插入成功" );
            } else {
                logger.info("========================影片排行榜数据表插入失败===========================================" );
            }
        } else {
            Integer rankNumber = filmRankLast.getRankNumber();
            // logger.info("====================================旧的排名：" + rankNumber );
            // 对影片排行榜表插入数据
            filmRank = new FilmRank();

            film = new Film();
            film.setFilmId(filmId);
            filmRank.setFilm(film);
            number = rankNumber + 1;
            logger.info("====================================新的排名：" + number );
            filmRank.setRankNumber(number);

            int i1 = filmRankMapper.insertFilmRank(filmRank);
            if (i1 > 0) {
                logger.info("====================================影片排行榜数据插入成功" );
            } else {
                logger.info("========================影片排行榜数据表插入失败===========================================" );
            }
        }

        if (i > 0) {
            logger.info("====================================影片数据插入成功" );
            return true;
        } else {
            logger.info("========================影片数据插入失败===========================================" );
            return false;
        }
    }

    @Override
    @Transactional
    public boolean deleteFilmByFilmId(Integer filmId) {
        int i1 = filmTypeRelationMapper.deleteFilmTypeRelationByFilmId(filmId);
        if (i1 > 0) {
            logger.info("====================================影片分类详情删除成功" );
        } else {
            logger.info("========================影片分类详情删除失败===========================================" );
        }
        int i2 = filmActorMapper.deleteFilmActorByFilmId(filmId);
        if (i1 > 0) {
            logger.info("====================================影片演员详情删除成功" );
        } else {
            logger.info("========================影片演员详情删除失败===========================================" );
        }


            FilmRank newfilmRank = null;
            Film film = null;
            // 根据传入的参数影片编号，查询到当前的排行名次
            FilmRank filmRankByFilmId = filmRankMapper.findFilmRankByFilmId(filmId);
            logger.info("===========================================================当前的排行名次：" +filmRankByFilmId);
            Integer number = filmRankByFilmId.getRankNumber();
            logger.info("===========================================================当前的排行名次：" +number);
            // 获取到排行表的总条数
            int count = filmRankMapper.CountFilmRank();
            logger.info("===========================================================总排行数：" +count);
            for (int j = 1; j < count - number ; j++) {
                Integer shangNumber = number + j;
                logger.info("===========================================================下一级的排行：" + shangNumber);
                FilmRank filmRankByshang = filmRankMapper.findFilmRankByRankNumber(shangNumber);
                logger.info("===========================================================下一级：" + filmRankByshang);
                Integer oldFilmId = filmRankByshang.getFilm().getFilmId();
                newfilmRank = new FilmRank();
                film = new Film();
                film.setFilmId(oldFilmId);
                newfilmRank.setFilm(film);
                newfilmRank.setRankNumber(shangNumber - 1);
                int shang = filmRankMapper.updateFilmRankByFilmRankId(newfilmRank);
                if (shang > 0) {
                    logger.info("=================================上升排行顺序修改成功==========================");
                } else {
                    logger.info("======================================上升排行顺序修改失败==========================");
                }

            }
        int i3 = filmRankMapper.deleteFilmRankByFilmId(filmId);
        if (i3 > 0) {
            logger.info("====================================影片排行删除成功" );

        } else {
            logger.info("========================影片排行删除入失败===========================================" );
        }

        int i = filmMapper.deleteFilmByFilmId(filmId);
        if (i > 0) {
            logger.info("====================================影片删除成功" );
            return true;
        } else {
            logger.info("========================影片删除入失败===========================================" );
            return false;
        }




    }

    @Override
    public boolean updateFilmByFilmId(Film film) {
        int i = filmMapper.updateFilmByFilmId(film);
        if (i > 0) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    @Transactional
    public PageInfo<Film> getFilmByCondition(Map<String, String> params) {
        // 分页页码
        String number = params.get("pageNum");
        if ("".equals(number)||number == null) {
            number = "1";
        }
        Integer pageNum = Integer.valueOf(number);

        String size= params.get("pageSize");
        if ("".equals(size)||size == null) {
            size = "1000";
        }
        Integer pageSize = Integer.valueOf(size);

        // 影片名称
        String filmName = params.get("filmName");
        // 上映时间
        String filmReleaseTime = params.get("filmReleaseTime");
        // 影片状态
        String filmStatus = params.get("filmStatus");

        Map<String, String> map = new HashMap<>();
        if ("".equals(filmName) || filmName == null) {
            map.put("filmName",null);
        } else {
            map.put("filmName","%" + filmName + "%");
        }
        if ("".equals(filmReleaseTime) || filmReleaseTime == null) {
            map.put("filmReleaseTime",null);
        } else {
            map.put("filmReleaseTime","%" + filmReleaseTime + "%");
        }
        if ("".equals(filmStatus) || filmStatus == null) {
            map.put("filmStatus",null);
        } else {
            map.put("filmStatus",filmStatus);
        }

        // 开始分页
        PageHelper.startPage(pageNum,pageSize);
        // 进行分页
        List<Film> filmList = filmMapper.findFilmByCondition(map);
        // 用PageInfo对结果进行包装
        PageInfo<Film> pageInfoFilm = new PageInfo<>(filmList);

        return pageInfoFilm;
    }

    @Override
    public Map<String, Object> getFilmByFilmId(Integer filmId) {

        HashMap<String, Object> map = new HashMap<>();

        Film film = filmMapper.findFilmByFilmId(filmId);
        // 影片编号
        map.put("filmId",film.getFilmId());
        // 影片名称
        map.put("filmName",film.getFilmName());
        // 影片简介
        map.put("filmContent",film.getFilmContent());
        // 时长
        map.put("filmRunTime",film.getFilmRunTime());
        // 上映时间
        map.put("filmReleaseTime",film.getFilmReleaseTime());
        // 封面
        map.put("filmCover",film.getFilmCover());
        // 预告片
        map.put("filmPrevue",film.getFilmPrevue());
        // 状态
        map.put("filmStatus",film.getFilmStatus());
        // 演员
        List<Actor> actors = actorMapper.getActorList(filmId);
        map.put("actors",actors);
        // 分类
        List<FilmType> filmTypes = filmTypeMapper.getFilmTypes(filmId);
        map.put("filmTypes",filmTypes);
        return map;
    }

    @Override
    public List<Film> getFilmListByexport() {
        List<Film> filmListByexport = filmMapper.findFilmListByexport();
        return filmListByexport;
    }
}
